#include "global.h"
#include "nrf24l01_reg.h"

#define CE_H (NRF24L01_PORT->BSRR = NRF24L01_PIN_CE)
#define CE_L (NRF24L01_PORT->BRR = NRF24L01_PIN_CE)
#define CSN_H (NRF24L01_PORT2->BSRR = NRF24L01_PIN_CSN)
#define CSN_L (NRF24L01_PORT2->BRR = NRF24L01_PIN_CSN)
#define IRQ_READ ((NRF24L01_PORT->IDR & NRF24L01_PIN_IRQ) ? 1 : 0)

const uint8_t TX_ADDR_BUF[NRF24L01_AW_SIZE] = {0xF0, 0xF0, 0xF0};    //{0xF0, 0xF0, 0xF0, 0xF0, 0xF0};    // 发送地址
const uint8_t RX_ADDR_P0_BUF[NRF24L01_AW_SIZE] = {0xF0, 0xF0, 0xF0}; //{0xF0, 0xF0, 0xF0, 0xF0, 0xF0}; // 接收地址

uint8_t nrf24l01_readReg(uint8_t regAddress)
{
    uint8_t data;

    CSN_L;                    // 使能SPI传输
    spi_swapByte(regAddress); // 发送寄存器号
    data = spi_swapByte(NOP); // 读取寄存器内容
    CSN_H;                    // 禁止SPI传输
    return data;              // 返回状态值
}

void nrf24l01_readRegs(uint8_t regAddress, uint8_t *data, uint8_t length)
{
    uint8_t i;

    CSN_L;                    // 使能SPI传输
    spi_swapByte(regAddress); // 发送寄存器值(位置)
    for (i = 0; i < length; i++)
    {
        data[i] = spi_swapByte(NOP); // 读出数据
    }
    CSN_H; // 关闭SPI传输
}

void nrf24l01_writeReg(uint8_t regAddress, uint8_t data)
{
    CSN_L;                    // 使能SPI传输
    spi_swapByte(regAddress); // 发送寄存器号
    spi_swapByte(data);       // 写入寄存器的值
    CSN_H;                    // 禁止SPI传输
}

void nrf24l01_writeRegs(uint8_t regAddress, const uint8_t *data, uint8_t length)
{
    uint8_t i;

    CSN_L;                    // 使能SPI传输
    spi_swapByte(regAddress); // 发送寄存器值(位置)
    for (i = 0; i < length; i++)
    {
        spi_swapByte(*data++); // 写入数据
    }
    CSN_H; // 关闭SPI传输
}

void nrf24l01_init(void)
{
    RCC_APB2PeriphClockCmd(NRF24L01_RCC, ENABLE);  // 使能GPIO的时钟 IRQ CE
    RCC_APB2PeriphClockCmd(NRF24L01_RCC2, ENABLE); // 使能GPIO的时钟 CSN

    GPIO_InitTypeDef GPIO_InitStructure = {
        .GPIO_Speed = GPIO_Speed_50MHz, // 50MHz
    };
    GPIO_InitStructure.GPIO_Pin = NRF24L01_PIN_CE;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; // 推挽输出
    GPIO_Init(NRF24L01_PORT, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Pin = NRF24L01_PIN_IRQ;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; // 上拉输入
    GPIO_Init(NRF24L01_PORT, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = NRF24L01_PIN_CSN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; // 推挽输出
    GPIO_Init(NRF24L01_PORT2, &GPIO_InitStructure);
}

void nrf24l01_setRxMode(void)
{
    uint8_t reg_val;
    uint8_t addr_buf[NRF24L01_AW_SIZE];

    while (1)
    {
        CE_L; // 进入待机模式

        /*---- 关键配置步骤，逐项验证 ----*/
        // 1. 配置CONFIG寄存器
        nrf24l01_writeReg(W_REGISTER + CONFIG, 0x0F);
        reg_val = nrf24l01_readReg(CONFIG);
        if (reg_val != 0x0F)
        {
            delay_ms(10);
            continue;
        }

        // 2. 清空FIFO（无需验证）
        nrf24l01_writeReg(FLUSH_RX, NOP);
        nrf24l01_writeReg(FLUSH_TX, NOP);

        // 3. 地址宽度配置
        nrf24l01_writeReg(W_REGISTER + SETUP_AW, NRF24L01_AW_SIZE - 2);
        reg_val = nrf24l01_readReg(SETUP_AW) + 2;
        if (reg_val != NRF24L01_AW_SIZE)
        {
            delay_ms(10);
            continue;
        }

        // 4. RF参数（速率、功率）
        nrf24l01_writeReg(W_REGISTER + RF_SETUP, 0x0E);
        reg_val = nrf24l01_readReg(RF_SETUP);
        if (reg_val != 0x0E)
        {
            delay_ms(10);
            continue;
        }

        // 5. 通信频率
        nrf24l01_writeReg(W_REGISTER + RF_CH, 0x00);
        reg_val = nrf24l01_readReg(RF_CH);
        if (reg_val != 0x00)
        {
            delay_ms(10);
            continue;
        }

        // 6. 接收地址P0
        nrf24l01_writeRegs(W_REGISTER + RX_ADDR_P0, RX_ADDR_P0_BUF, NRF24L01_AW_SIZE);
        nrf24l01_readRegs(RX_ADDR_P0, addr_buf, NRF24L01_AW_SIZE);
        if (memcmp(RX_ADDR_P0_BUF, addr_buf, NRF24L01_AW_SIZE) != 0)
        {
            delay_ms(10);
            continue;
        }

        // 7. 动态负载长度
        nrf24l01_writeReg(W_REGISTER + DYNPD, 0x01);
        reg_val = nrf24l01_readReg(DYNPD);
        if (reg_val != 0x01)
        {
            delay_ms(10);
            continue;
        }

        // 8. 自动应答
        nrf24l01_writeReg(W_REGISTER + EN_AA, 0x01);
        reg_val = nrf24l01_readReg(EN_AA);
        if (reg_val != 0x01)
        {
            delay_ms(10);
            continue;
        }

        // 9. 使能接收通道0
        nrf24l01_writeReg(W_REGISTER + EN_RXADDR, 0x01);
        reg_val = nrf24l01_readReg(EN_RXADDR);
        if (reg_val != 0x01)
        {
            delay_ms(10);
            continue;
        }

        // 10. FEATURE配置
        nrf24l01_writeReg(W_REGISTER + FEATURE, 0x06);
        reg_val = nrf24l01_readReg(FEATURE);
        if (reg_val != 0x06)
        {
            delay_ms(10);
            continue;
        }

        // 11. 禁用自动重发
        nrf24l01_writeReg(W_REGISTER + SETUP_RETR, 0x00);
        reg_val = nrf24l01_readReg(SETUP_RETR);
        if (reg_val != 0x00)
        {
            delay_ms(10);
            continue;
        }

        //--- 所有配置通过 ---
        CE_H;  // 启动接收模式
        break; // 退出循环
    }
}

void nrf24l01_setTxMode(void)
{
    uint8_t reg_val;
    uint8_t addr_buf[NRF24L01_AW_SIZE];

    while (1)
    {
        CE_L; // 进入待机模式

        /*---- 关键配置步骤，逐项验证 ----*/
        // 1. 配置CONFIG寄存器
        nrf24l01_writeReg(W_REGISTER + CONFIG, 0x0E);
        reg_val = nrf24l01_readReg(CONFIG);
        if (reg_val != 0x0E)
        {
            delay_ms(10);
            continue;
        }

        // 2. 清空FIFO（无需验证）
        nrf24l01_writeReg(FLUSH_RX, NOP);
        nrf24l01_writeReg(FLUSH_TX, NOP);

        // 3. 地址宽度配置
        nrf24l01_writeReg(W_REGISTER + SETUP_AW, NRF24L01_AW_SIZE - 2);
        reg_val = nrf24l01_readReg(SETUP_AW) + 2;
        if (reg_val != NRF24L01_AW_SIZE)
        {
            delay_ms(10);
            continue;
        }

        // 4. RF参数（速率、功率）
        nrf24l01_writeReg(W_REGISTER + RF_SETUP, 0x0E);
        reg_val = nrf24l01_readReg(RF_SETUP);
        if (reg_val != 0x0E)
        {
            delay_ms(10);
            continue;
        }

        // 5. 通信频率
        nrf24l01_writeReg(W_REGISTER + RF_CH, 0x00);
        reg_val = nrf24l01_readReg(RF_CH);
        if (reg_val != 0x00)
        {
            delay_ms(10);
            continue;
        }

        // 6. 发送地址
        nrf24l01_writeRegs(W_REGISTER + TX_ADDR, TX_ADDR_BUF, NRF24L01_AW_SIZE);
        nrf24l01_readRegs(TX_ADDR, addr_buf, NRF24L01_AW_SIZE);
        if (memcmp(TX_ADDR_BUF, addr_buf, NRF24L01_AW_SIZE) != 0)
        {
            delay_ms(10);
            continue;
        }

        // 7. 接收地址P0
        nrf24l01_writeRegs(W_REGISTER + RX_ADDR_P0, RX_ADDR_P0_BUF, NRF24L01_AW_SIZE);
        nrf24l01_readRegs(RX_ADDR_P0, addr_buf, NRF24L01_AW_SIZE);
        if (memcmp(RX_ADDR_P0_BUF, addr_buf, NRF24L01_AW_SIZE) != 0)
        {
            delay_ms(10);
            continue;
        }

        // 8. 动态负载长度
        nrf24l01_writeReg(W_REGISTER + DYNPD, 0x01);
        reg_val = nrf24l01_readReg(DYNPD);
        if (reg_val != 0x01)
        {
            delay_ms(10);
            continue;
        }

        // 9. 使能接收通道0
        nrf24l01_writeReg(W_REGISTER + EN_RXADDR, 0x01);
        reg_val = nrf24l01_readReg(EN_RXADDR);
        if (reg_val != 0x01)
        {
            delay_ms(10);
            continue;
        }

        // 10. FEATURE配置
        nrf24l01_writeReg(W_REGISTER + FEATURE, 0x06);
        reg_val = nrf24l01_readReg(FEATURE);
        if (reg_val != 0x06)
        {
            delay_ms(10);
            continue;
        }

        // 11. 禁用自动重发
        nrf24l01_writeReg(W_REGISTER + SETUP_RETR, 0x00);
        reg_val = nrf24l01_readReg(SETUP_RETR);
        if (reg_val != 0x00)
        {
            delay_ms(10);
            continue;
        }

        //--- 所有配置通过 ---
        CE_H;  // 启动发送模式
        break; // 退出循环
    }
}

uint8_t nrf24l01_readData(uint8_t *rxPayload, uint8_t *rxPayloadLen)
{
    uint8_t status;

    if (IRQ_READ == 0) // 如果IRQ引脚为低电平
    {
        CE_L;                                           // 进入待机模式
        status = nrf24l01_readReg(R_REGISTER + STATUS); // 读取状态寄存器
        nrf24l01_writeReg(W_REGISTER + STATUS, status); // 清除中断
        CE_H;                                           // 启动接收模式

        if (status & RX_DR) // 如果接收到数据
        {
            *rxPayloadLen = nrf24l01_readReg(R_RX_PL_WID); // 读取通道0 接收到的数据长度
            if (*rxPayloadLen > 32)
            {
                nrf24l01_writeReg(FLUSH_RX, NOP); // 清除接收缓存器
                return NRF24L01_READ_RX_PAYLOAD_LEN_ERROR;
            }
            nrf24l01_readRegs(R_RX_PAYLOAD, rxPayload, *rxPayloadLen); // 读取接收到的数据
            nrf24l01_writeReg(FLUSH_RX, NOP);                          // 清除接收缓存器
            return SUCCESS;
        }
    }
    return NRF24L01_READ_EMPTY; // 如果没有接收到数据
}

void nrf24l01_setAck(uint8_t *ackPayload, uint8_t ackPayloadLen)
{
    nrf24l01_writeRegs(W_ACK_PAYLOAD + 0x00, ackPayload, ackPayloadLen); // 写入通道0 随ACK返回的负载（返回数据到发射端）
}

void nrf24l01_sendData(uint8_t *txPayload, uint8_t txPayloadLen)
{
    nrf24l01_writeRegs(W_TX_PAYLOAD, txPayload, txPayloadLen); // 在发送数据缓存器发送要发送的数据
}

uint8_t nrf24l01_getAck(uint8_t *ackPayload, uint8_t *ackPayloadLen)
{
    uint8_t status;

    if (IRQ_READ == 0) // 检查中断
    {
        CE_L;                                           // 进入待机模式
        status = nrf24l01_readReg(R_REGISTER + STATUS); // 读取状态寄存器
        nrf24l01_writeReg(W_REGISTER + STATUS, status); // 清除中断
        CE_H;                                           // 启动发送模式

        if (status & MAX_RT) // 如果发送失败,超过最大重发次数
        {
            nrf24l01_writeReg(FLUSH_TX, NOP); // 清除发送缓存器
            return NRF24L01_SEND_MAX_RT;
        }
        else if (status & TX_DS) // 如果发送成功,接收到应答信号
        {
            if (status & RX_DR) // 如果接收到数据
            {
                *ackPayloadLen = nrf24l01_readReg(R_RX_PL_WID); // 读取接收到的ack数据长度
                if (*ackPayloadLen > 32)
                {
                    nrf24l01_writeReg(FLUSH_RX, NOP); // 清除接收缓存器
                    return NRF24L01_SEND_ACK_PAYLOAD_LEN_ERROR;
                }
                nrf24l01_readRegs(R_RX_PAYLOAD, ackPayload, *ackPayloadLen); // 读取接收到的数据
            }
            return SUCCESS;
        }
        return NRF24L01_SEND_UNKNOWN_ERROR; // 未知错误
    }
    else
    {
        nrf24l01_writeReg(FLUSH_TX, NOP); // 清除发送缓存器
        return NRF24L01_SEND_TIMEOUT;     // 返回超时错误
    }
}
